Creating Abstractions Using Relevance Reasoning

ion mapping sf Intended semantics sI Predicate abstraction Replace occurrences of P1; : : : ; Pn by P P = P1 [ : : : [ Pn Replace occurrences of P1; : : : ; Pn by P P = P1 \ : : : \ Pn Object abstraction a1; : : : ; an ! a P (a) i P (a1) ^ : : : ^ P (an) Function abstraction f ! f 0 f 0 is an approximation of f Table 1: Example irrelevance subjects tion of the domain, but only with clauses in the KB that represent a set of intended models. Moreover, as noted by in [Subramanian, 1989], a purely modeltheoretic account of irrelevance will not capture our intuitions about the notion. Finally, since our main goal in de ning irrelevance is to provide a basis for automatically creating abstractions, we will consider de nitions that involve the actual clauses in the KB. Formally, an irrelevance subject s is a pair (sf ; sI) specifying a syntactic abstraction mapping [Plaisted, 1981], sf , on clauses and the intended mapping on interpretations sI (see Table 1). The mapping sI represents the simpli cation we intend to make to the conceptualization of the domain via the abstraction (see [Nayak and Levy, 1994] for a more detailed account of such simpli cations).2 As an example, consider a subject which is a set of predicate arguments. We denote such a subject by a list of pairs (qi; ni), where qi is a predicate and ni is an integer less or equal to the arity of qi. In our example, the irrelevant arguments are f(F light; 3); (Route; 3)g. The mapping sf would map the literals of the form F light(x; y; c; a) to the literal F light(x; y; a) (and likewise for Route). The mapping sI would map the relation denoted by F light to the relation resulting from projecting out its third column. The mapping sf is de ned on literals and extended in the natural way to clauses. Following [Plaisted, 1981], we require that sf satisfy the following restrictions: (1) if L is a literal, then sf (:L) = :sf (L), and (2) if a clause C subsumes D, then sf (C) subsumes sf (D). Applying the mapping sf to all the clauses in may result in an inconsistent theory. Therefore, we will apply sf only to clauses that are independent of s, as we de ne below. The notion of independence will also form the basis for our de nition of irrelevance. De nition 1: Let be a knowledge base and s = (sf ; sI) be an irrelevance subject. A clause is independent of s if for any interpretation I: I j= =) sI(I) j= sf ( ): Intuitively, a clause is independent of s if sf ( ) does not decrease the set of possible models, and therefore does not enable us to derive conclusions that did not follow from the original KB. For example, the rule r2 is independent of the predicate arguments 2Note that sI is not uniquely determined by sf , as shown by the rst two entries in Table 1. f(F light; 3); (Route; 3)g, but it is not independent of f(F light; 4); (Route; 4)g. To see this, consider the interpretation I1 and its corresponding interpretation sI (I1): Flight: f(a; b; 100; UA); (b; c; 150;NW )g sI ! f(a; b; 100); (b; c; 150)g Route: f(a; b; 100; UA; 1); (b; c; 150; NW; 1)g sI ! f(a; b; 100; 1); (b; c;150; 1)g American: fUA;NWg sI ! fUA;NWg. While the interpretation I1 satis es r2, sI(I1) does not satisfy the rule resulting from projecting out f(F light; 4); (Route; 4)g from r2: r00 2 : Flight(x; z; c1) ^Route(z; y; c2; l) ^ :American(a)) Route(x;y; c1 + c2; l + 1) which enables us to derive the incorrect conclusion Route(a; c; 250; 2). Based on the notion of independence, we de ne irrelevance as follows: De nition 2: Let be a KB and s = (sf ; sI) be an irrelevance subject and be a query. The subject s is weakly irrelevant to (denoted by WI(s; ; )) if there is some derivation D of such that all the clauses in Base(D) are independent of s. The subject s is strongly irrelevant to , (denoted by SI(s; ; )) if for all derivations D of , all the clauses in Base(D) are independent of s. Note that these de nitions can be viewed as instances in the space of de nitions of irrelevance proposed in [Levy and Sagiv, 1993]. It is more useful to state and derive irrelevance claims that hold with respect to a set of knowledge bases. Formally, if is a set of KBs, we de ne WI(s; ; ) to hold if WI(s; ; ) for every 2 (and similarly for SI). Consider Example 1, where is the set of KBs consisting of the rules r1{r5 and some set of ground unit clauses of the predicate F light. The predicate arguments s = f(F light; 3); (Route; 3)g are strongly irrelevant to ground queries that are instances of q = American(a)^AirlineRoute(x; y; a; l), because, as the query-tree in Figure 1 shows, only the rules r1, r2 and r5 and ground unit clauses can appear in derivations of the query and these are all independent of s (note that ground unit positive clauses are independent of any set of predicate arguments). If we add the rule r6 : Flight(x; z; c1; a) ^Route(z;y; c2; a; l)^ (c1 + c2 < 500)) Route(x;y; c1 + c2; a; l + 1) which is not independent of s, then s would be only weakly irrelevant to the query (since r6 is redundant and therefore, if there is a derivation of the query, there will be a derivation with r6 and one without it). Our de nitions enable us to give a logical justi cation for creating abstractions. The following theorem states that if s is weakly irrelevant to a query, then the KB resulting from abstracting all the independent clauses will be su cient for answering the query. Theorem 3: Let be a knowledge base and let s = (sf ; sI) be an irrelevance subject such that sf is an abstraction mapping. Let s be the KB de ned by: s = fsf ( ) j 2 and is independent of sg: Let q be a query and suppose WI(s; q; ) holds. Then ` q =) s ` sf (q) and, if sf (q) = q then3 s j= q =) j= q: Note that the second part of the theorem does not depend on the inference mechanism used. Furthermore, if our inference rules are complete (e.g., refutation resolution), then the above theorem implies ` q () s ` q and j= q () s j= q: Proof sketch: The rst half of the theorem follows from Plaisted [Plaisted, 1981]. For the second half, suppose s j= q and let I be a model of , i.e., I j= . We need to show that I j= q. By the de nition of independence and the construction of s, we get sI(I) j= s and therefore, sI(I) j= q. However, since I and sI(I) are identical for the symbols appearing in q, it follows that I j= q. The importance of Theorem 3 is that it gives a logical justi cation for creating an abstraction that is especially t for the speci c set of queries. As we describe in the next section, it also gives us a method for developing algorithms for automatically creating abstractions. It is important to note that Theorem 3 provides a justi cation for using a speci c abstract KB, namely s. One advantage of s is that it can be e ciently generated from the original theory. However, we can sometimes add clauses to s to obtain a stronger theory (as done in [Tenenberg, 1990]), and therefore lose less information in the abstract KB. We do not discuss this extension here. Automatically Creating Abstractions The importance of the formulation presented in the previous section is that we can now clearly address the problem of automatically creating abstractions for a given set of queries, by automatically deriving irrelevance claims. Speci cally, to use Theorem 3 we need to automatically derive claims of the formWI(s; q; ). 3Note that this restriction e ectively means that the irrelevance subject does not appear explicitly in the query. One way of deriving such a claim is to nd a subset of , such that q will necessarily have a derivation that does not include clauses in , and such that the clauses in are all independent of s. It follows from the previous section that we can abstract by sf ( ). Therefore, a general method for automatically creating abstractions has two steps (1) automatically nd (i.e., a set of irrelevant clauses) and (2) automatically detect independence of a clause (i.e., the independence of from s). These steps are discussed in the following sections. Determining Irrelevance Methods for detecting irrelevance of clauses to a query are described in [Levy and Sagiv, 1993; Levy, 1993] and [Subramanian, 1989]. For example, we can use the query-tree [Levy and Sagiv, 1992] (shown in Figure 1) to show that only that the rules r1; r2 and r5 and ground unit clauses involving American airlines can be used in derivations of the query. Consequently, all other clauses (including the rules r3 and r4) are irrelevant to the query. AirlineRoute(x; y; a; l) fAmerican(a)g r5 Route(x;y; c;a; l) ( ( ( ( ( ( ( XXXXXX fAmerican(a)g r1 r2 r3 r4 fc1 + c2 = c;American(a)g PPP Flight(x; y; c; a)Flight(x; y; c1; a) Route(x;y; c2; a; l 1) fAmerican(a)g fAmerican(a)g fAmerican(a)g Figure 1: An example of a query-tree showing the possible symbolic derivations of AirlineRoute(x; y; a; l) ^ American(a). Note that the semantics of the interpreted predicates are taken into consideration in the construction of the query-tree. The literals shown in the brackets of each node denote the constraints that need to be satis ed by facts generated at this node, and are used as a criterion for terminating the tree (e.g., the nodes Route(x; y; c2; a; l 1) and Route(x; y; c; a; l) have the same constraints and therefore only the latter is expanded). Note that rules r3 and r4 are not expanded because they would yield an unsatis able set of constraints (fAmerican(a);:American(a)g). Several aspects of the query-tree make it especially useful in our context. First, recall that determining irrelevance of a clause requires that we can decide that there is some derivation of the query that does not use it. For irrelevance reasoning to be of practical use, we must be able to determine irrelevance without actually solving the query. To that end, the query-tree considers only part of the KB in its reasoning. Speci cally, it considers only the rules in the KB, and high level constraints on the ground unit clauses that may appear (e.g., all ight costs are positive). Consequently, when it decides that a clause is irrelevant, the conclusion holds for all KBs that have the given set of rules, independent of the ground unit clauses. Furthermore, irrelevance is determined w.r.t. a set of queries, and these may involve disjunctions and conjunctions of literals. Second, in its irrelevance reasoning, the querytree considers the semantics of some predicates (e.g., order predicates, <;>; ; ; 6=, or sort predicates, e.g., American). In many applications, considering the semantics of such predicates enables us to nd interactions between clauses and therefore to deem clauses irrelevant. Finally, the query-tree can be built in time that is linear in the number of rules in the KB. The query-tree actually detects strongly irrelevant clauses, i.e., clauses that are not part of any derivation of the query (note that strong irrelevance is a sufcient condition for weak irrelevance). In fact, under certain conditions (e.g., function-free or non-recursive rules) the query-tree will nd all the irrelevant clauses. As pointed out in [Levy and Sagiv, 1993], removing strongly-irrelevant clauses is guaranteed not to slow down inferences (and usually to speed them up signi cantly), whereas removing weakly irrelevant clauses may actually cause inference to be slowed down. In our context this observation is important because creating an abstraction based on strong irrelevance guarantees that using the abstract theory will result in more e cient inference. Algorithms for detecting weakly irrelevant clauses are described in [Subramanian, 1989; Levy, 1993]. For general clause form knowledge bases, connection graph methods [Kowalski, 1975; Sickel, 1976; Chang, 1979] provide su cient conditions for strong and weak irrelevance. Determining Independence of Predicate Arguments Algorithms for determining independence of a clause are speci c to a given type of irrelevance subject. In this section we describe a novel algorithm for determining independence of an irrelevance subject consisting of a set of predicate arguments. First we describe a syntactic condition for checking whether a clause C is independent of a given subject s. This condition can be used in conjunction with the algorithms of the previous section to determine irrelevance of s. However, a more interesting question is how we can automatically nd the maximal set of irrelevant predicate arguments, given the set of relevant clauses. We describe an algorithm that uses the syntactic condition to nd such a maximal set. We use the following notation in this section. Given a clause C, we denote by Neg(C) and Pos(C) the negative literals and the positive literals in C, respectively (e.g., if C is f:P (x); Q(x)g then Neg(C) is f:P (x)g and Pos(C) is fQ(x)g. We assume that C is not redundant, i.e., there is no subset of C that is logically equivalent to C, and that C is not a tautology. Theorem 4: A clause C is independent of the set of predicate arguments s = f(P1; i1); : : : ; (Pn; in)g if the following conditions hold for 1 j n. If the predicate Pj occurs in Neg(C), then the argument in position ij of that occurrence: A1: must be a variable (i.e., not a constant or a functional term). A2: the variable must appear at most once in Neg(C). A3: if that variable also appears (by itself, or part of a functional term) in position k of a predicate Q in Pos(C), then (Q; k) 2 s. The proof of the theorem (given in [Levy, 1993]) proceeds by case analysis, showing that for every model I of C, sI(I) will be a model of sf (C). As an example, the clause f:P (x; y; z);:Q(x); R(y)g is independent of f(P; 3)g. It is not independent of f(Q; 1); (P; 1)g (violates A2) or of f(P; 2)g (violates A3). Given an argument (P; i) that appears in C, we can determine the unique minimal set of arguments, PC(C;P; i), such that (P; i) 2 PC(C;P; i) and C is independent of PC(C;P; i). This is done by iteratively adding the arguments that are required to be in s by condition A3, and checking whether the nal set violates A1 or A2. Note that there may be no such set PC(C;P; i). In that case, we say that (P; i) is needed in C. We use the conditions of Theorem 4 to devise the following algorithm that nds the maximal set of irrelevant predicate arguments w.r.t. a query. Given a set of relevant clauses , the algorithm (shown in Figure 2) nds the maximal set of predicate arguments s that does not include any argument appearing in the query (which are assumed to be relevant), such that all clauses in are independent of s. The algorithmmaintains a list of irrelevant arguments, which initially includes all the arguments of all predicates, except those appearing in the query. It makes one pass over the clauses in and either removes arguments from the list of irrelevant arguments, or adds conditions for the inclusion arguments in the list. These conditions specify a set of additional arguments that must be included (implied by A3). Finally, it removes from the irrelevant list any argument whose conditions are not satis ed. Consider the application of the algorithm to the rules r1; r2; r5 in Example 1, with the query AirlineF light(x; y; a; l)^American(a). The set R initially includes all the arguments of F light and Route. When considering the rule r1, the algorithm adds the argument (Route; i) to the preconditions of (F light; i), for i = 1; : : : ; 3, and removes the argument (F light; 4) from R. Considering rule r2, the algorithm removes the arguments (F light; 2), (Route; 1) and (Route; 4) fromR. As a consequence, the argument (F light; 1) is procedure nd-irrelevant-arguments( ;q)begin / are the clauses and q is the query. /P = The predicates appearing in , and not in q.R = f(P; i) j P 2 P and i is an argument of P g.for every s 2 R, Preconditions(s)= fg.for every C 2 do:for every (P; i) 2 Rif P appears in C and (P; i) is needed in Cthen remove (P; i) from R.elseif PC(C;P; i) 6 R thenremove (P; i) from R.else add fPC(C;P; i) f(P; i)ggto Preconditions ((P; i)).repeatif (P; i) 2 R and (Q; j) 2 Preconditions ((P; i))and (Q; j) 62 Rthen remove (P; i) from R.until no changes are made to R.return R.end.Figure 2: Algorithm for nding a maximal set of irrel-evant predicate arguments.removed fromR because its precondition was removed.Finally, considering rule r5, the arguments (Route; 2)and (Route; 5) are removed from R because the ar-guments (AirlineF light; 2) and (AirlineF light; 4) arenot members of R. Therefore, the algorithm returnsthat the arguments (F light; 3) and (Route; 3) are ir-relevant to the given query.The algorithm nds the maximal set of predicate ar-guments that satis es conditions A1, A2 and A3. Thisfollows from the observation that for every argumentin the returned set, its precondition arguments (i.e.,the arguments in PC(C;P; i)) are also in R. Further-more, every argument that was removed from R waseither needed in some clause or required some otherargument that is not a member of R. The time com-plexity of the algorithm is bounded by j jR2, wherej j is the number of clauses in and R is the sum ofthe number of argument of relations in .Conclusions and Related WorkWe presented a formal connection between the no-tion of irrelevance and the creation of abstractions.At its core, it is based on associating an abstrac-tion with some detail that it removes from the rep-resentation of the domain, and justifying the abstrac-tion by observing that the detail is irrelevant to thequery. To make this connection we extended pre-vious work on irrelevance reasoning to consider ir-relevance of new subjects (e.g., predicate arguments,predicate re nements). Using the connection, we pre-sented a general method for automatically generat-ing abstractions that are suited for a particular setof queries. As an instance of this method, we de-scribed a novel and e cient algorithm for automati-cally creating abstractions in which we remove irrele-vant arguments of predicates. Abstraction by project-ing out arguments was also suggested in [Hobbs, 1985;Subramanian, 1989], but no algorithm for doing so wasgiven. Our algorithm is a generalization of a methodfor pushing projections [Ramakrishnan et al., 1988] indatalog programs. Our algorithm handles arbitraryclauses and the semantics interpreted predicates. Ad-ditional instances of the general algorithm for creatingabstractions can also be devised. For example, thework of Tenenberg [Tenenberg, 1990] e ectively pro-vides an algorithm for determining independence of aclause from a predicate re nement,4 thereby yieldingan algorithm for determining irrelevance of predicatere nements.The computational savings gained by using abstrac-tions has been demonstrated both theoretically andempirically (e.g., [Bacchus and Yang, 1992; Knoblock,1991; Ellman, 1993]). In our case the savings achievedby abstractions will be maximized if we can identifylarge sets of queries for which we can create the sameabstract KB, and therefore amortize the cost of cre-ating the abstract KB over many queries. One of thekey advantages of using the query-tree for relevancereasoning is that it enables us to create abstractionsthat are tailored for sets of queries. Experiments pre-sented in [Levy, 1993] show that the cost of buildingthe query-tree is negligible compared to the savingsachieved by using it.Studying abstractions in our framework o ers sev-eral additional advantages. First, we can exploit do-main knowledge (stated as irrelevance claims) in cre-ating abstractions for a given query. We can eitheruse such claims directly to justify abstractions or com-bine them with other methods to derive logical conclu-sions from them (e.g., using algorithms from [Subrama-nian, 1989; Levy and Sagiv, 1993]), and obtain justi -cations for additional abstractions. Second, it providesa framework for choosing and combining existing KBsthat each make certain abstractions of the domain,by labeling the KBs with the irrelevance assumptionsunderlying their abstractions. An example of such atask arises in Compositional Modeling [Falkenhainerand Forbus, 1991; Iwasaki and Levy, 1994], where weneed to combine descriptions of di erent aspects of aphysical device to create an adequate and parsimoniousmodel of the device. Similar situations arise in rea-soning with contexts (e.g., [Guha, 1991]) and in het-erogenous distributed knowledge based systems. Fi-nally, our framework provides insight into the utilityof reasoning with abstractions (e.g., abstractions basedon strong-irrelevance are guaranteed to yield savings),and to composability of abstractions (by composingthe irrelevance statements underlying them).In their theory of abstraction, Giunchiglia and4A predicate re nement is a set of predicates P1; : : : ; Pnwhose union denotes a predicate P . Walsh [Giunchiglia and Walsh, 1992] distinguish twoclasses of abstractions, TD and TI. Roughly, TDabstractions are those in which theorems derived inthe abstract theory hold also in the original theory,whereas TI abstractions are those in which every the-orem in the original theory will have a theorem inthe abstract theory (but an abstract theorem need nothave a corresponding theorem in the original theory).The abstractions we considered are TD abstractions(i.e., will not introduce wrong conclusions), but arealso TI w.r.t. the query, i.e., a solution to the queryin the original theory is guaranteed to have a corre-sponding solution in the abstract theory (but otherderivable theorems may be lost in the abstract the-ory). This aligns with the intuition that removing ir-relevant knowledge should not enable us to lose theability to solve the query or to derive new false con-clusions. Creating an abstract KB can also be viewedas an instance of knowledge compilation [Selman andKautz, 1991]. The key di erence in our work is that wecompile the KB w.r.t. a given set of queries, and there-fore we can determine exactly when the compiled KB isapplicable. Knoblock [Knoblock, 1990] also considersautomatic generation of abstractions that are suitedfor a speci c query (i.e., planning goal), by removingpreconditions of actions. His ALPINE system gener-ates TI abstractions, but provides the planner with acondition that enables it to prune the search needed tore ne an abstract solution.TI-abstractions have been used as a means of con-trolling problem solving in complex domains, by usingabstractions to structure the search space hierarchi-cally (e.g., [Sacerdoti, 1974; Plaisted, 1981; Knoblock,1990; Ellman, 1993]). In that work, the intuition (for-mally analized in [Bacchus and Yang, 1992]) is thatalthough the information removed from one level ofthe hierarchy to the other is not always irrelevant, itwill be irrelevant in most cases, and therefore, in thesecases it will not be necessary to backtrack through theabstraction hierarchy. To apply our framework to thiscontext we are currently considering an extension of ir-relevance reasoning to handle approximate irrelevanceclaims that can be used to justify abstracting knowl-edge that is irrelevant with high probability.AcknowledgementsI would like to thank TomEllman, Hiroshi Motoda andPandu Nayak for very useful discussions on the topicsdescribed in this paper.ReferencesBacchus, Fahiem and Yang, Qiang 1992. The expectedvalue of hierarchical problem-solving. In Proceedings ofAAAI-92. 369{374.Chang, C. L. 1979. Resolution plans in theorem proving.In Proceedings of the Sixth International Joint Conferenceon Arti cial Intelligence. 143{148.Ellman, Thomas, editor 1992. Working Notes of theWorkshop on Approximation and Abstraction of Compu-tational Theories. American Association for Arti cial In-telligence.Ellman, Thomas 1993. Abstraction via approximate sym-metry. In Proceedings of the 13th International Joint Con-ference on Arti cial Intelligence. 916{921.Falkenhainer, Brian and Forbus, Ken 1991. Compositionalmodeling: Finding the right model for the job. Arti cialIntelligence 51:95{143.Giunchiglia, Fausto and Walsh, Toby 1992. A theory ofabstraction. Arti cial Intelligence 56 (3).Guha, Ramanathan V. 1991. Contexts: A Formalizationand Some Applications. Ph.D. Dissertation, Stanford Uni-versity, Stanford, CA.Hobbs, Jerry R. 1985. Granularity. In Proceedings ofIJCAI-85. 432{435.Iwasaki, Yumi and Levy, Alon Y. 1994. Automated modelselection for simulation. In Proceedings of AAAI-94.Knoblock, Craig A. 1990. Learning abstraction hierarchiesfor problem solving. In Proceedings of AAAI-90.Knoblock, Craig A. 1991. Search reduction in hierarchicalproblem solving. In Proceedings of AAAI-91. 686{691.Kowalski, Robert 1975. A proof procedure using connec-tion graphs. Journal of the ACM 22(4): 572{595.Levy, Alon Y. and Sagiv, Yehoshua 1992. Constraintsand redundancy in Datalog. In The Proceedings of theEleventh ACM SIGACT-SIGMOD-SIGART Symposiumon Principles of Database Systems (PODS). 67{80.Levy, Alon Y. and Sagiv, Yehoshua 1993. Exploiting irrel-evance reasoning to guide problem solving. In Proceedingsof the 13th International Joint Conference on Arti cialIntelligence. 138{144.Levy, Alon Y. 1993. Irrelevance Reasoning in KnowledgeBased Systems. Ph.D. Dissertation, Stanford University,Stanford, CA.Nayak, P. Pandurang and Levy, Alon Y. 1994. A semantictheory of abstractions: A preliminary report. TechnicalReport, AT&T; Bell Laboratories.Plaisted, D. 1981. Theorem proving with abstraction. Ar-ti cial Intelligence 16:47{108.Ramakrishnan, Raghu; Beeri, Catriel; and Krishna-murthy, Ravi 1988. Optimizing existential datalog queries.In Proceedings of PODS-88. 89{101.Sacerdoti, Earl D. 1974. Planning in a hierarchy of ab-straction spaces. Arti cial Intelligence 5:115{135.Selman, Bart and Kautz, Henry 1991. Knowledge com-pilation using horn approximations. In Proceedings ofAAAI-91. 904{909.Sickel, Susan 1976. A search technique for clause inter-connectivity graphs. IEEE Transactions on ComputersC-25(8):823{835.Subramanian, Devika 1989. A Theory of Justi ed Refor-mulations. Ph.D. Dissertation, Stanford University, Stan-ford, CA.Tenenberg, Josh D. 1990. Abstracting rst order theories.In Benjamin, Paul, editor 1990, Change of Representationand Inductive Bias. Kluwer, Boston, Mass.